home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / fish / 676-700 / 681 / term / source.lha / termReview.c < prev    next >
C/C++ Source or Header  |  1992-05-09  |  14KB  |  755 lines
  1. /*
  2. **    $Id: termReview.c,v 1.2 92/05/08 20:49:59 olsen Sta Locker: olsen $
  3. **    $Revision: 1.2 $
  4. **    $Date: 92/05/08 20:49:59 $
  5. **
  6. **    Support routines for the review buffer (not the log book!)
  7. **
  8. **    Copyright © 1990-1992 by Olaf `Olsen' Barthel & MXM
  9. **        All Rights Reserved
  10. */
  11.  
  12. #include "termGlobal.h"
  13.  
  14.     /* Scroller gadget flags. */
  15.  
  16. #define PROP_FLAGS    (AUTOKNOB | FREEVERT | PROPBORDERLESS | PROPNEWLOOK)
  17.  
  18.     /* Local routines. */
  19.  
  20. STATIC VOID        ReviewUpdatePot(VOID);
  21. STATIC VOID __stdargs    ReviewWrites(STRPTR String,...);
  22. STATIC VOID __regargs    PrintReviewLine(STRPTR Buffer,LONG Line);
  23. STATIC VOID __regargs    RefreshReview(LONG Top);
  24. STATIC BYTE        ReviewQuery(VOID);
  25. STATIC UBYTE __regargs    GetReviewChar(BYTE WaitForIt);
  26.  
  27.     /* Local variables. */
  28.  
  29. STATIC struct IBox     ReviewBox;
  30. STATIC struct IOStdReq    *ReviewWriteRequest,
  31.             *ReviewReadRequest;
  32.  
  33. STATIC struct MsgPort    *ReviewWritePort;
  34.  
  35. STATIC LONG         ReviewWidth = -1,ReviewHeight,
  36.              ReviewX,ReviewY;
  37. STATIC UBYTE         ReviewChar;
  38. STATIC LONG         ReviewColumns,ReviewLines,ReviewTop,ReviewGlobalLines;
  39. STATIC LONG         ReviewBody = -1,ReviewPot = -1;
  40.  
  41. STATIC struct Image     ReviewPropImage;
  42.  
  43. STATIC struct PropInfo ReviewPropInfo =
  44. {
  45.     PROP_FLAGS,
  46.     0,MAXPOT,
  47.     0,MAXBODY,
  48.     0,0,
  49.     0,0,
  50.     0,0
  51. };
  52.  
  53. STATIC struct Gadget ReviewPropGadget =
  54. {
  55.     NULL,
  56.     0,0,
  57.     0,0,
  58.     GFLG_GADGHCOMP | GFLG_RELRIGHT | GFLG_RELHEIGHT,
  59.     GACT_IMMEDIATE | GACT_FOLLOWMOUSE,
  60.     GTYP_PROPGADGET,
  61.     &ReviewPropImage,
  62.     NULL,
  63.     NULL,
  64.     0,
  65.     (APTR)&ReviewPropInfo,
  66.     0,
  67.     NULL
  68. };
  69.  
  70.     /* ReviewUpdatePot():
  71.      *
  72.      *    Update size and position of the scroller gadget.
  73.      */
  74.  
  75. STATIC VOID
  76. ReviewUpdatePot()
  77. {
  78.     if(ReviewGlobalLines)
  79.     {
  80.         LONG Body,Pot;
  81.  
  82.         if(ReviewGlobalLines > ReviewLines)
  83.         {
  84.             Body    = (ReviewLines * MAXBODY) / ReviewGlobalLines;
  85.             Pot    = (ReviewTop * MAXPOT) / (ReviewGlobalLines - ReviewLines);
  86.         }
  87.         else
  88.         {
  89.             Body    = MAXBODY;
  90.             Pot    = 0;
  91.         }
  92.  
  93.         if(Body != ReviewBody || Pot != ReviewPot)
  94.         {
  95.             NewModifyProp(&ReviewPropGadget,ReviewWindow,NULL,PROP_FLAGS,0,Pot,0,Body,1);
  96.  
  97.             ReviewBody    = Body;
  98.             ReviewPot    = Pot;
  99.         }
  100.     }
  101. }
  102.  
  103.     /* ReviewUp(LONG Count):
  104.      *
  105.      *    Move the contents of the review buffer up.
  106.      */
  107.  
  108. STATIC VOID __regargs
  109. ReviewUp(LONG Count)
  110. {
  111.     if(Count == 1)
  112.     {
  113.         if(ReviewTop)
  114.         {
  115.             ReviewTop--;
  116.  
  117.             ReviewWrites("\033[T");
  118.  
  119.             ObtainSemaphore(BufferSemaphore);
  120.  
  121.             PrintReviewLine(BufferLines[ReviewTop],1);
  122.  
  123.             ReviewUpdatePot();
  124.  
  125.             ReleaseSemaphore(BufferSemaphore);
  126.         }
  127.     }
  128.     else
  129.     {
  130.         LONG NewTop = ReviewTop;
  131.  
  132.         if(NewTop >= Count)
  133.             NewTop -= Count;
  134.         else
  135.             NewTop = 0;
  136.  
  137.         if(NewTop != ReviewTop)
  138.         {
  139.             ReviewTop = NewTop;
  140.  
  141.             RefreshReview(ReviewTop);
  142.  
  143.             ReviewUpdatePot();
  144.         }
  145.     }
  146. }
  147.  
  148.     /* ReviewDown(LONG Count):
  149.      *
  150.      *    Move the contents of the review buffer down.
  151.      */
  152.  
  153. STATIC VOID __regargs
  154. ReviewDown(LONG Count)
  155. {
  156.     if(Count == 1)
  157.     {
  158.         if(ReviewTop + ReviewLines < Lines)
  159.         {
  160.             LONG Last;
  161.  
  162.             ReviewTop++;
  163.  
  164.             ReviewWrites("\033[S");
  165.  
  166.             ObtainSemaphore(BufferSemaphore);
  167.  
  168.             if((Last = ReviewTop + ReviewLines) >= Lines)
  169.                 Last = Lines - 1;
  170.  
  171.             PrintReviewLine(BufferLines[Last],ReviewLines + 1);
  172.  
  173.             ReviewUpdatePot();
  174.  
  175.             ReleaseSemaphore(BufferSemaphore);
  176.         }
  177.     }
  178.     else
  179.     {
  180.         LONG NewTop = ReviewTop;
  181.  
  182.         if((NewTop + Count + ReviewLines) > Lines)
  183.         {
  184.             if((NewTop = Lines - ReviewLines) < 0)
  185.                 NewTop = 0;
  186.         }
  187.         else
  188.             NewTop += Count;
  189.  
  190.         if(NewTop != ReviewTop)
  191.         {
  192.             ReviewTop = NewTop;
  193.  
  194.             RefreshReview(ReviewTop);
  195.  
  196.             ReviewUpdatePot();
  197.         }
  198.     }
  199. }
  200.  
  201.     /* ReviewWrites(STRPTR String,...):
  202.      *
  203.      *    Write a string into the review buffer window.
  204.      */
  205.  
  206. STATIC VOID __stdargs
  207. ReviewWrites(STRPTR String,...)
  208. {
  209.     va_list    VarArgs;
  210.  
  211.     va_start(VarArgs,String);
  212.     VSPrintf(SharedBuffer,String,VarArgs);
  213.     va_end(VarArgs);
  214.  
  215.     ReviewWriteRequest -> io_Command    = CMD_WRITE;
  216.     ReviewWriteRequest -> io_Data        = SharedBuffer;
  217.     ReviewWriteRequest -> io_Length        = -1;
  218.  
  219.     DoIO(ReviewWriteRequest);
  220. }
  221.  
  222.     /* PrintReviewLine(STRPTR Buffer,LONG Line):
  223.      *
  224.      *    Write the contents of a buffer line into the review buffer window.
  225.      */
  226.  
  227. STATIC VOID __regargs
  228. PrintReviewLine(STRPTR Buffer,LONG Line)
  229. {
  230.     WORD Length = ((ULONG *)Buffer)[-1];
  231.  
  232.     if(Length > ReviewColumns)
  233.         Length = ReviewColumns;
  234.  
  235.     ReviewWrites("\033[%ldH",Line);
  236.  
  237.     ReviewWriteRequest -> io_Command    = CMD_WRITE;
  238.     ReviewWriteRequest -> io_Data        = Buffer;
  239.     ReviewWriteRequest -> io_Length        = Length;
  240.  
  241.     DoIO(ReviewWriteRequest);
  242.  
  243.     ReviewWrites("\033[0K");
  244. }
  245.  
  246.     /* RefreshReview(LONG Top):
  247.      *
  248.      *    Refresh the contents of the review buffer window.
  249.      */
  250.  
  251. STATIC VOID __regargs
  252. RefreshReview(LONG Top)
  253. {
  254.     LONG i,Last,Line = 0;
  255.  
  256.     ReviewGlobalLines = Lines;
  257.  
  258.     ObtainSemaphore(BufferSemaphore);
  259.  
  260.     if((Last = Top + ReviewLines + 1) >= Lines)
  261.         Last = Lines;
  262.  
  263.     for(i = Top ; i < Last ; i++)
  264.         PrintReviewLine(BufferLines[i],++Line);
  265.  
  266.     if(Line <= ReviewLines)
  267.         ReviewWrites("\033[0J");
  268.  
  269.     ReleaseSemaphore(BufferSemaphore);
  270. }
  271.  
  272.     /* ReviewQuery():
  273.      *
  274.      *    Update the current review buffer window dimensions.
  275.      */
  276.  
  277. STATIC BYTE
  278. ReviewQuery()
  279. {
  280.     struct ConUnit    *Unit = (struct ConUnit *)ReviewWriteRequest -> io_Unit;
  281.     BYTE         Refresh = FALSE;
  282.  
  283.     if(ReviewColumns != Unit -> cu_XMax)
  284.     {
  285.         Refresh = TRUE;
  286.  
  287.         ReviewColumns = Unit -> cu_XMax;
  288.     }
  289.  
  290.     if(ReviewLines != Unit -> cu_YMax)
  291.     {
  292.         LONG Delta = ABS(Unit -> cu_YMax - ReviewLines);
  293.  
  294.         Refresh = TRUE;
  295.  
  296.         if(ReviewLines)
  297.         {
  298.             if(Unit -> cu_YMax > ReviewLines)
  299.             {
  300.                 if((ReviewTop = ReviewTop - Delta) < 0)
  301.                     ReviewTop = 0;
  302.             }
  303.             else
  304.                 ReviewTop += Delta;
  305.         }
  306.  
  307.         ReviewLines = Unit -> cu_YMax;
  308.     }
  309.  
  310.     if(Refresh)
  311.         ReviewUpdatePot();
  312.  
  313.     return(Refresh);
  314. }
  315.  
  316.     /* GetReviewChar(BYTE WaitForIt):
  317.      *
  318.      *    Get the next character present at the console read port.
  319.      */
  320.  
  321. STATIC UBYTE __regargs
  322. GetReviewChar(BYTE WaitForIt)
  323. {
  324.     UBYTE Char;
  325.  
  326.     if(!WaitForIt)
  327.     {
  328.         if(!CheckIO(ReviewReadRequest))
  329.             return(0);
  330.     }
  331.  
  332.     WaitIO(ReviewReadRequest);
  333.  
  334.     Char = ReviewChar;
  335.  
  336.     ReviewReadRequest -> io_Command    = CMD_READ;
  337.     ReviewReadRequest -> io_Data    = &ReviewChar;
  338.     ReviewReadRequest -> io_Length    = 1;
  339.  
  340.     SendIO(ReviewReadRequest);
  341.  
  342.     return(Char);
  343. }
  344.  
  345.     /* DeleteReview():
  346.      *
  347.      *    Delete the review buffer.
  348.      */
  349.  
  350. VOID
  351. DeleteReview()
  352. {
  353.     if(ReviewWriteRequest)
  354.     {
  355.         if(ReviewWriteRequest -> io_Device)
  356.         {
  357.             ReviewWriteRequest -> io_Command = CMD_CLEAR;
  358.  
  359.             DoIO(ReviewWriteRequest);
  360.  
  361.             CloseDevice(ReviewWriteRequest);
  362.         }
  363.  
  364.         DeleteIORequest(ReviewWriteRequest);
  365.  
  366.         ReviewWriteRequest = NULL;
  367.     }
  368.  
  369.     if(ReviewReadRequest)
  370.     {
  371.         if(ReviewReadRequest -> io_Device)
  372.         {
  373.             if(!CheckIO(ReviewReadRequest))
  374.                 AbortIO(ReviewReadRequest);
  375.  
  376.             WaitIO(ReviewReadRequest);
  377.         }
  378.  
  379.         FreeVec(ReviewReadRequest);
  380.  
  381.         ReviewReadRequest = NULL;
  382.     }
  383.  
  384.     ReviewPot = ReviewBody = -1;
  385.  
  386.     if(ReviewWindow)
  387.     {
  388.         ReviewWidth    = ReviewWindow -> Width;
  389.         ReviewHeight    = ReviewWindow -> Height;
  390.         ReviewX        = ReviewWindow -> LeftEdge;
  391.         ReviewY        = ReviewWindow -> TopEdge;
  392.  
  393.         CloseWindow(ReviewWindow);
  394.  
  395.         ReviewWindow = NULL;
  396.     }
  397.  
  398.     if(ReviewWritePort)
  399.     {
  400.         DeleteMsgPort(ReviewWritePort);
  401.  
  402.         ReviewWritePort = NULL;
  403.     }
  404.  
  405.     if(ReviewPort)
  406.     {
  407.         DeleteMsgPort(ReviewPort);
  408.  
  409.         ReviewPort = NULL;
  410.     }
  411. }
  412.  
  413.     /* CreateReview():
  414.      *
  415.      *    Create the review buffer.
  416.      */
  417.  
  418. BYTE
  419. CreateReview()
  420. {
  421.     if(ReviewWindow)
  422.     {
  423.         WindowToFront(ReviewWindow);
  424.  
  425.         ActivateWindow(ReviewWindow);
  426.  
  427.         return(TRUE);
  428.     }
  429.     else
  430.     {
  431.         if(ReviewWidth == -1)
  432.         {
  433.             ReviewWidth        = Screen -> Width;
  434.             ReviewHeight        = Screen -> WBorTop + Screen -> WBorBottom + 1 + Screen -> Font -> ta_YSize + 5 * Screen -> Font -> ta_YSize;
  435.             ReviewX            = 0;
  436.             ReviewY            = Screen -> BarHeight + 1;
  437.  
  438.             ReviewBox . Left    = 0;
  439.             ReviewBox . Top        = Screen -> BarHeight + 1;
  440.             ReviewBox . Width    = Screen -> Width;
  441.             ReviewBox . Height    = Screen -> Height - (Screen -> BarHeight + 1);
  442.         }
  443.  
  444.         ReviewPropGadget . TopEdge    = Screen -> WBorTop + Screen -> Font -> ta_YSize + 2;
  445.         ReviewPropGadget . LeftEdge    = -15;
  446.         ReviewPropGadget . Width    = 14;
  447.         ReviewPropGadget . Height    = -(ReviewPropGadget . TopEdge + Screen -> WBorBottom + 9);
  448.  
  449.         if(ReviewWindow = OpenWindowTags(NULL,
  450.             WA_Left,        ReviewX,
  451.             WA_Top,            ReviewY,
  452.             WA_Width,        ReviewWidth,
  453.             WA_Height,        ReviewHeight,
  454.             WA_MinWidth,        Screen -> WBorLeft + Screen -> WBorRight + 15 * 8,
  455.             WA_MinHeight,        Screen -> WBorTop + Screen -> WBorBottom + 1 + 2 * Screen -> Font -> ta_YSize,
  456.             WA_MaxWidth,        Screen -> Width,
  457.             WA_MaxHeight,        Screen -> Height,
  458.             WA_DragBar,        TRUE,
  459.             WA_CloseGadget,        TRUE,
  460.             WA_DepthGadget,        TRUE,
  461.             WA_SizeGadget,        TRUE,
  462.             WA_IDCMP,        IDCMP_GADGETDOWN | IDCMP_MOUSEMOVE,
  463.             WA_Title,        LocaleString(MSG_TERMREVIEW_REVIEWBUFFER_TXT),
  464.             WA_CustomScreen,    Screen,
  465.             WA_SimpleRefresh,    TRUE,
  466.             WA_RMBTrap,        TRUE,
  467.             WA_Activate,        TRUE,
  468.             WA_Zoom,        &ReviewBox,
  469.         TAG_DONE))
  470.         {
  471.             AddGadget(ReviewWindow,&ReviewPropGadget,-1);
  472.             RefreshGadgets(&ReviewPropGadget,ReviewWindow,NULL);
  473.  
  474.             SetFont(ReviewWindow -> RPort,CurrentFont);
  475.  
  476.             if(ReviewWritePort = CreateMsgPort())
  477.             {
  478.                 if(ReviewPort = CreateMsgPort())
  479.                 {
  480.                     if(ReviewWriteRequest = CreateIORequest(ReviewPort,sizeof(struct IOStdReq)))
  481.                     {
  482.                         if(ReviewReadRequest = (struct IOStdReq *)AllocVec(sizeof(struct IOStdReq),MEMF_PUBLIC | MEMF_CLEAR))
  483.                         {
  484.                             ReviewWriteRequest -> io_Data = ReviewWindow;
  485.  
  486.                             if(!OpenDevice("console.device",CONU_SNIPMAP,ReviewWriteRequest,CONFLAG_NODRAW_ON_NEWSIZE))
  487.                             {
  488.                                 BYTE Pen;
  489.  
  490.                                 switch(Config . ColourMode)
  491.                                 {
  492.                                     case COLOUR_EIGHT:
  493.                                     case COLOUR_SIXTEEN:    Pen = 7;
  494.                                                 break;
  495.  
  496.                                     default:        Pen = 1;
  497.                                                 break;
  498.                                 }
  499.  
  500.                                 CopyMem(ReviewWriteRequest,ReviewReadRequest,sizeof(struct IOStdReq));
  501.  
  502.                                 ReviewReadRequest -> io_Message . mn_ReplyPort = ReviewPort;
  503.  
  504.                                 ReviewWrites("\033[0 p\033[11;12{\033[3%ldm",Pen);
  505.  
  506.                                 ReviewQuery();
  507.  
  508.                                 ObtainSemaphore(BufferSemaphore);
  509.  
  510.                                 if((ReviewTop = Lines - ReviewLines) < 0)
  511.                                     ReviewTop = 0;
  512.  
  513.                                 ReleaseSemaphore(BufferSemaphore);
  514.  
  515.                                 RefreshReview(ReviewTop);
  516.  
  517.                                 ReviewUpdatePot();
  518.  
  519.                                 ReviewReadRequest -> io_Command    = CMD_READ;
  520.                                 ReviewReadRequest -> io_Data    = &ReviewChar;
  521.                                 ReviewReadRequest -> io_Length    = 1;
  522.  
  523.                                 SendIO(ReviewReadRequest);
  524.  
  525.                                 return(TRUE);
  526.                             }
  527.                         }
  528.                     }
  529.                 }
  530.             }
  531.         }
  532.  
  533.         DeleteReview();
  534.     }
  535.  
  536.     return(FALSE);
  537. }
  538.  
  539.     /* UpdateReview():
  540.      *
  541.      *    Update the contents of the review buffer window.
  542.      */
  543.  
  544. VOID
  545. UpdateReview(BYTE Force)
  546. {
  547.     if(ReviewPort)
  548.     {
  549.         if(Force || (Lines >= ReviewGlobalLines && ReviewGlobalLines <= ReviewLines))
  550.             RefreshReview(ReviewTop);
  551.  
  552.         ReviewGlobalLines = Lines;
  553.  
  554.         ReviewUpdatePot();
  555.     }
  556. }
  557.  
  558.     /* HandleReview():
  559.      *
  560.      *    Process console and user input.
  561.      */
  562.  
  563. BYTE
  564. HandleReview()
  565. {
  566.     BYTE Result = FALSE;
  567.  
  568.     if(ReviewWindow)
  569.     {
  570.         struct IntuiMessage *Message;
  571.  
  572.         if(Message = (struct IntuiMessage *)GetMsg(ReviewWindow -> UserPort))
  573.         {
  574.             ReplyMsg((struct Message *)Message);
  575.  
  576.             if(ReviewGlobalLines > ReviewLines)
  577.             {
  578.                 ReviewTop = (ReviewPropInfo . VertPot * (ReviewGlobalLines - ReviewLines)) / MAXPOT;
  579.  
  580.                 RefreshReview(ReviewTop);
  581.             }
  582.  
  583.             Result = TRUE;
  584.         }
  585.     }
  586.  
  587.     if(ReviewPort)
  588.     {
  589.         UBYTE Char;
  590.  
  591.         if(Char = GetReviewChar(FALSE))
  592.         {
  593.             if(Char == CSI)
  594.             {
  595.                 WORD Count = 0;
  596.  
  597.                 Char = GetReviewChar(TRUE);
  598.  
  599.                 switch(Char)
  600.                 {
  601.                     case 'A':    ReviewUp(1);
  602.                             break;
  603.  
  604.                     case 'B':    ReviewDown(1);
  605.                             break;
  606.  
  607.                     case 'T':    ReviewUp(ReviewLines);
  608.                             break;
  609.  
  610.                     case 'S':    ReviewDown(ReviewLines);
  611.                             break;
  612.  
  613.                     default:    SharedBuffer[Count++] = Char;
  614.  
  615.                             while(Char = GetReviewChar(FALSE))
  616.                             {
  617.                                 SharedBuffer[Count++] = Char;
  618.  
  619.                                 if(Char == 'v' || Char == '|')
  620.                                     break;
  621.                             }
  622.  
  623.                             SharedBuffer[Count] = 0;
  624.  
  625.                             if(!strcmp(SharedBuffer,"0 v"))
  626.                             {
  627.                                 LONG Size;
  628.  
  629.                                 if(Size = LoadClip(SharedBuffer,256))
  630.                                     SerWrite(SharedBuffer,Size);
  631.                             }
  632.                             else
  633.                             {
  634.                                 if(!strncmp(SharedBuffer,"11",2))
  635.                                 {
  636.                                     DeleteReview();
  637.  
  638.                                     return(Result);
  639.                                 }
  640.  
  641.                                 if(!strncmp(SharedBuffer,"12",2))
  642.                                 {
  643.                                     if(ReviewQuery())
  644.                                         RefreshReview(ReviewTop);
  645.                                 }
  646.                             }
  647.  
  648.                             break;
  649.                 }
  650.             }
  651.             else
  652.             {
  653.                 if(Config . StripBit8)
  654.                     Char &= 0x7F;
  655.  
  656.                 if(Status == STATUS_HOLDING)
  657.                 {
  658.                     if(Char == XOF)
  659.                     {
  660.                         SerWrite(&Char,1);
  661.  
  662.                         Status = STATUS_READY;
  663.                     }
  664.                     else
  665.                         DoSomeBeep();
  666.                 }
  667.                 else
  668.                 {
  669.                         /* Convert chars
  670.                          * as approriate.
  671.                          */
  672.  
  673.                     if(Char == '\n')
  674.                     {
  675.                         switch(Config . SendLF)
  676.                         {
  677.                             case LF_IGNORE:    break;
  678.  
  679.                             case LF_ASLF:    goto SendIt;
  680.  
  681.                             case LF_ASLFCR:    SerWrite("\n\r",2);
  682.                                     break;
  683.                         }
  684.  
  685.                         return(TRUE);
  686.                     }
  687.  
  688.                     if(Char == '\r')
  689.                     {
  690.                         switch(Config . SendCR)
  691.                         {
  692.                             case CR_IGNORE:    break;
  693.  
  694.                             case CR_ASCR:    goto SendIt;
  695.  
  696.                             case CR_ASCRLF:    SerWrite("\r\n",2);
  697.                                     break;
  698.                         }
  699.  
  700.                         return(TRUE);
  701.                     }
  702.  
  703.                         /* Stop in/output. */
  704.  
  705.                     if(Char == XON)
  706.                     {
  707.                         if(Config . PassThrough)
  708.                         {
  709.                             SerWrite(&Char,1);
  710.  
  711.                             return(TRUE);
  712.                         }
  713.                         else
  714.                         {
  715.                             if(Config . Handshaking == HANDSHAKING_XONXOFF)
  716.                                 Status = STATUS_HOLDING;
  717.                         }
  718.                     }
  719.  
  720.                         /* Restart in/output. */
  721.  
  722.                     if(Char == XOF)
  723.                     {
  724.                         if(Config . PassThrough)
  725.                         {
  726.                             SerWrite(&Char,1);
  727.  
  728.                             return(TRUE);
  729.                         }
  730.                     }
  731.  
  732.                         /* Convert special
  733.                          * Amiga characters into
  734.                          * alien IBM dialect.
  735.                          */
  736.  
  737. SendIt:                    if(Config . Font == FONT_IBM)
  738.                     {
  739.                         if(IBMConversion[Char])
  740.                             SerWrite(&IBMConversion[Char],1);
  741.                         else
  742.                             SerWrite(&Char,1);
  743.                     }
  744.                     else
  745.                         SerWrite(&Char,1);
  746.                 }
  747.             }
  748.  
  749.             return(TRUE);
  750.         }
  751.     }
  752.  
  753.     return(Result);
  754. }
  755.